home *** CD-ROM | disk | FTP | other *** search
/ Amiga News 95 / Amiga News 95.iso / dpat / dpat31 / iobject / sources.lha / sources / Integer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-23  |  7.2 KB  |  344 lines
  1. // Gestionnaire de Integer gadget V0.28
  2. // (C) 1992 Christophe PASSUELLO
  3. // Tue Jan 26 14:17:59 1993
  4.  
  5.  
  6. #include <exec/types.h>
  7. #include <exec/memory.h>
  8. #include "mytypes.h"
  9. #define  INTUITION_PREFERENCES_H 0
  10. #include <intuition/intuition.h>
  11. #include "IObject_priv.h"
  12.  
  13.  
  14. struct String
  15. {
  16.     struct ObjectTMV *TMV;
  17.     UWORD  ObjectID;
  18.     UWORD  Flags;
  19.     STRPTR LabelText;
  20.     struct TextFont *Font;
  21.     struct Window *window;
  22.     struct Requester *requester;
  23.     UWORD  ClassFlags;
  24.     struct Box BorderBox;
  25.     struct Gadget Gadget;
  26.     struct StringInfo StringInfo;
  27.     UWORD  MaxLength;
  28. };
  29.  
  30. #define STRINGMAX    260
  31.  
  32. #define LENGTHMAX    12
  33. struct Integer
  34. {
  35.     struct ObjectTMV *TMV;
  36.     UWORD  ObjectID;
  37.     UWORD  Flags;
  38.     STRPTR LabelText;
  39.     struct TextFont *Font;
  40.     struct Window *window;
  41.     struct Requester *requester;
  42.     UWORD  ClassFlags;
  43.     struct Box BorderBox;
  44.     struct Gadget Gadget;
  45.     struct StringInfo StringInfo;
  46.     LONG   MinInt;
  47.     LONG   MaxInt;
  48.     LONG   CurInt;
  49.     UBYTE  Buffer[LENGTHMAX];
  50. };
  51.  
  52. #define LONG_MAX    ((long)0x7FFFFFFF)
  53. #define LONG_MIN    ((long)0x80000000)
  54.  
  55. // Buffer Undo pour les entiers
  56. PRIVATE UBYTE  Undo[STRINGMAX];
  57.  
  58. // methodes generiques pour les StringObject
  59. PRIVATE VOID DisplayString(struct String *);
  60. PRIVATE VOID EraseString(struct String *);
  61. VOID OnStringObject(struct String *);
  62. PRIVATE VOID ActivateString(struct String *);
  63. PRIVATE VOID FreeString(struct String *);
  64.  
  65. // methodes pour les Integer
  66. PRIVATE BOOL IntegerMsg(struct Integer *, struct IntuiMessage *);
  67. VOID ModifyInteger(struct Integer *, LONG, LONG, LONG);
  68. PRIVATE LONG IntegerValue(struct Integer *);
  69.  
  70. // methodes pour les String
  71. PRIVATE BOOL StringMsg(struct String *, struct IntuiMessage *);
  72. PRIVATE VOID ModifyString(struct String *, STRPTR);
  73. PRIVATE STRPTR StringValue(struct String *);
  74.  
  75.  
  76. // TMV pour les Integers
  77. const static struct ObjectTMV IntegerMethod=
  78. {
  79.     CLASS_INTEGER, sizeof(struct Integer),
  80.     DisposeObject, IntegerMsg, AddObject, RemoveObject, DisplayString, EraseString,
  81.     ModifyInteger, IntegerValue, OffObjectGad, OnStringObject, ActivateString
  82. };
  83.  
  84.  
  85. // TMV pour les String
  86. const static struct ObjectTMV StringMethod=
  87. {
  88.     CLASS_STRING, sizeof(struct String),
  89.     FreeString, StringMsg, AddObject, RemoveObject, DisplayString, EraseString,
  90.     ModifyString, StringValue, OffObjectGad, OnStringObject, ActivateString
  91. };
  92.  
  93.  
  94. //
  95. // Initialise les gadgets de chaine
  96. //
  97. PRIVATE VOID InitStringObject(struct String *str, struct NewString *ns)
  98. {
  99.     BOOL bord;
  100.  
  101.     InitObjectGad( (struct ObjectGad *) str, (struct NewObject *) ns);
  102.  
  103.     // ajuste la boite du gadget
  104.     bord = (str->ClassFlags & STR_SINGLEBORD) ? TRUE : FALSE;
  105.     AdjustBox( (struct Box *) &str->Gadget.LeftEdge, bord);
  106.  
  107.     // mettre un espace entre bordure et gadget
  108.     AdjustBox( (struct Box *) &str->Gadget.LeftEdge, TRUE);
  109.     
  110.     str->Gadget.Flags = GADGHCOMP;
  111.     str->Gadget.Activation = RELVERIFY;
  112.  
  113.     if (str->ClassFlags & STR_RIGHT)
  114.         str->Gadget.Activation |= STRINGRIGHT;
  115.     if (str->ClassFlags & STR_CENTER)
  116.         str->Gadget.Activation |= STRINGCENTER;
  117.  
  118.     str->Gadget.GadgetType = STRGADGET;
  119.     str->Gadget.SpecialInfo = &str->StringInfo;
  120. }
  121.  
  122.  
  123. //
  124. // Cree un Integer
  125. //
  126. struct Integer *CreateInteger(struct NewInteger *ni, UWORD ID)
  127. {
  128.     struct Integer *in;
  129.  
  130.     if (in = (struct Integer *) AllocMem(sizeof(struct Integer), MEMF_PUBLIC|MEMF_CLEAR))
  131.     {
  132.         in->TMV = &IntegerMethod;
  133.         in->ObjectID = ID;
  134.  
  135.         // recupere les champs de NewInteger
  136.         InitStringObject( (struct String *) in, (struct NewString *) ni);
  137.         in->Gadget.Activation |= LONGINT;
  138.  
  139.         // initialise le stringinfo
  140.         in->StringInfo.Buffer = in->Buffer;
  141.         in->StringInfo.UndoBuffer = Undo;
  142.         in->StringInfo.Buffer[0] = 0;
  143.  
  144.         // initialise le nombre de car max
  145.         in->StringInfo.MaxChars = 11;
  146.         in->MaxInt = LONG_MAX;
  147.         in->MinInt = LONG_MIN;
  148.     }
  149.     return(in);
  150. }
  151.  
  152.  
  153. //
  154. // Cree un String
  155. //
  156. struct String *CreateString(struct NewString *ns, UWORD ID)
  157. {
  158.     struct String *str;
  159.  
  160.     if (str = (struct String *) AllocMem(sizeof(struct String), MEMF_PUBLIC|MEMF_CLEAR))
  161.     {
  162.         str->TMV = &StringMethod;
  163.         str->ObjectID = ID;
  164.  
  165.         // recupere les champs de NewInteger
  166.         InitStringObject( (struct String *) str, (struct NewString *) ns);
  167.  
  168.         // initialise le stringinfo
  169.         if (str->StringInfo.Buffer = AllocMem(ns->MaxLength, MEMF_CLEAR|MEMF_PUBLIC))
  170.         {
  171.             if (ns->Text)
  172.                 strcpy(str->StringInfo.Buffer, ns->Text);
  173.  
  174.             str->StringInfo.UndoBuffer = Undo;
  175.  
  176.             // initialise le nombre de car max
  177.             str->StringInfo.MaxChars = str->MaxLength = ns->MaxLength;
  178.         }
  179.         else
  180.         {
  181.             FreeString(str);
  182.             str = NULL;
  183.         }
  184.     }
  185.     return(str);
  186. }
  187.  
  188.  
  189. //
  190. // Libere le stringObject
  191. //
  192. PRIVATE VOID FreeString(struct String *str)
  193. {
  194.     if (str)
  195.     {
  196.         if (str->StringInfo.Buffer)
  197.             FreeMem(str->StringInfo.Buffer, str->MaxLength);
  198.         DisposeObject(str)
  199.     }
  200. }
  201.  
  202.  
  203. //
  204. // Renvoie l'etat de l'Integer
  205. //
  206. PRIVATE LONG IntegerValue(struct Integer *in)
  207. {
  208.     return (in->CurInt);
  209. }
  210.  
  211.  
  212. //
  213. // Renvoie l'etat de l'Integer
  214. //
  215. PRIVATE STRPTR StringValue(struct String *str)
  216. {
  217.     return (str->StringInfo.Buffer);
  218. }
  219.  
  220.  
  221. //
  222. // Modifie l'integer
  223. //
  224. PRIVATE VOID ModifyInteger(struct Integer *in, LONG cur, LONG min, LONG max)
  225. {
  226.     in->MaxInt = max;
  227.     in->MinInt = min;
  228.     in->CurInt = cur;
  229.  
  230.     // mets le cur dans le buffer en ASCII
  231.     sprintf(in->Buffer, "%d", cur);
  232.  
  233.     if (!(in->Flags & OBJ_DISABLED))
  234.         RefreshGList(&in->Gadget, in->window, in->requester, 1L);
  235. }
  236.  
  237.  
  238. //
  239. // Modifie le string
  240. //
  241. PRIVATE VOID ModifyString(struct String *str, STRPTR text)
  242. {
  243.     strcpy(str->StringInfo.Buffer, text);
  244.  
  245.     if (!(str->Flags & OBJ_DISABLED))
  246.         RefreshGList(&str->Gadget, str->window, str->requester, 1L);
  247. }
  248.  
  249.  
  250. //
  251. // gestion de l'IntuiMessage pour le String
  252. //
  253. PRIVATE BOOL StringMsg(struct String *str, struct IntuiMessage *msg)
  254. {
  255.     return (TRUE);
  256. }
  257.  
  258.  
  259. //
  260. // gestion de l'IntuiMessage pour l'Integer
  261. //
  262. PRIVATE BOOL IntegerMsg(struct Integer *in, struct IntuiMessage *msg)
  263. {
  264.     BOOL changed;
  265.  
  266.     // verifie si l'entier est dans l'intervalle
  267.     if ((in->StringInfo.LongInt > in->MaxInt) || (in->StringInfo.LongInt < in->MinInt))
  268.     {
  269.         DisplayBeep(in->window->WScreen);
  270.         ActivateString( (struct String *) in);
  271.         changed = FALSE;
  272.     }
  273.     else
  274.     {
  275.         in->CurInt = in->StringInfo.LongInt;
  276.         changed = TRUE;
  277.     }
  278.     return (changed);
  279. }
  280.  
  281.  
  282. //
  283. // Efface le StringObject
  284. //
  285. PRIVATE VOID EraseString(struct String *str)
  286. {
  287.     EraseObjectFrame( (struct Object *) str, (struct Box *) &str->BorderBox);
  288. }
  289.  
  290.  
  291. //
  292. // Affiche le StringObject
  293. //
  294. PRIVATE VOID DisplayString(struct String *str)
  295. {
  296.     struct RastPort *rp;
  297.     struct TextEnv env;
  298.     UBYTE bord;
  299.  
  300.     if (str->window)
  301.     {
  302.         rp = str->window->RPort;
  303.         bord = (str->ClassFlags & STR_SINGLEBORD) ? BOX_1IN : BOX_2OUT;
  304.  
  305.         SaveTextEnv(str->window->RPort, &env);
  306.         FastDraw3DBox( (struct Box *) &str->BorderBox, rp, bord);
  307.         PrintObjectLabel( (struct Object *) str, (struct Box *) &str->BorderBox);
  308.         RestoreTextEnv(rp, &env);
  309.         RefreshGList(&str->Gadget, str->window, str->requester, 1L);
  310.  
  311.         if (str->Flags & OBJ_DISABLED)
  312.             OffObjectGad( (struct ObjectGad *) str);
  313.     }
  314. }
  315.  
  316. //
  317. // Active un string
  318. //
  319. PRIVATE VOID ActivateString(struct String *str)
  320. {
  321.     if (!(str->Flags & OBJ_DISABLED))
  322.         ActivateGadget(&str->Gadget, str->window, str->requester);
  323. }
  324.  
  325.  
  326. //
  327. // Unghoste un StringObject
  328. //
  329. PRIVATE VOID OnStringObject(struct String *str)
  330. {
  331.     struct RastPort *rp;
  332.  
  333.     if (str->Flags & OBJ_DISABLED)
  334.     {
  335.         rp = str->window->RPort;
  336.  
  337.         OnGadget( &str->Gadget, str->window, str->requester);
  338.         str->Flags &= (~OBJ_DISABLED);
  339.  
  340.         EraseBox( (struct Box *) &str->Gadget.LeftEdge, rp );
  341.         RefreshGList(&str->Gadget, str->window, str->requester, 1L );
  342.     }
  343. }
  344.